940 lines (940 with data), 90.2 kB

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8XnVMPBXmtRa"
      },
      "source": [
        "# TensorNetworks in Neural Networks.\n",
        "\n",
        "Here, we have a small toy example of how to use a TN inside of a fully connected neural network.\n",
        "\n",
        "First off, let's install tensornetwork"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7HGRsYNAFxME"
      },
      "source": [
        "# !pip install tensornetwork\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "# Import tensornetwork\n",
        "import tensornetwork as tn\n",
        "import random\n",
        "import time\n",
        "# Set the backend to tesorflow\n",
        "# (default is numpy)\n",
        "tn.set_default_backend(\"tensorflow\")\n",
        "np.random.seed(42)\n",
        "random.seed(42)\n",
        "tf.random.set_seed(42)"
      ],
      "execution_count": 62,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g1OMCo5XmrYu"
      },
      "source": [
        "# TensorNetwork layer definition\n",
        "\n",
        "Here, we define the TensorNetwork layer we wish to use to replace the fully connected layer. Here, we simply use a 2 node Matrix Product Operator network to replace the normal dense weight matrix.\n",
        "\n",
        "We TensorNetwork's NCon API to keep the code short."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wvSMKtPufnLp"
      },
      "source": [
        "class TNLayer(tf.keras.layers.Layer):\n",
        "\n",
        "  def __init__(self):\n",
        "    super(TNLayer, self).__init__()\n",
        "    # Create the variables for the layer.\n",
        "    self.a_var = tf.Variable(tf.random.normal(shape=(32, 32, 2),\n",
        "                                              stddev=1.0/32.0),\n",
        "                             name=\"a\", trainable=True)\n",
        "    self.b_var = tf.Variable(tf.random.normal(shape=(32, 32, 2),\n",
        "                                              stddev=1.0/32.0),\n",
        "                             name=\"b\", trainable=True)\n",
        "    self.bias = tf.Variable(tf.zeros(shape=(32, 32)),\n",
        "                            name=\"bias\", trainable=True)\n",
        "\n",
        "  def call(self, inputs):\n",
        "    # Define the contraction.\n",
        "    # We break it out so we can parallelize a batch using\n",
        "    # tf.vectorized_map (see below).\n",
        "    def f(input_vec, a_var, b_var, bias_var):\n",
        "      # Reshape to a matrix instead of a vector.\n",
        "      input_vec = tf.reshape(input_vec, (32, 32))\n",
        "\n",
        "      # Now we create the network.\n",
        "      a = tn.Node(a_var)\n",
        "      b = tn.Node(b_var)\n",
        "      x_node = tn.Node(input_vec)\n",
        "      a[1] ^ x_node[0]\n",
        "      b[1] ^ x_node[1]\n",
        "      a[2] ^ b[2]\n",
        "\n",
        "      # The TN should now look like this\n",
        "      #   |     |\n",
        "      #   a --- b\n",
        "      #    \\   /\n",
        "      #      x\n",
        "\n",
        "      # Now we begin the contraction.\n",
        "      c = a @ x_node\n",
        "      result = (c @ b).tensor\n",
        "\n",
        "      # To make the code shorter, we also could've used Ncon.\n",
        "      # The above few lines of code is the same as this:\n",
        "      # result = tn.ncon([x, a_var, b_var], [[1, 2], [-1, 1, 3], [-2, 2, 3]])\n",
        "\n",
        "      # Finally, add bias.\n",
        "      return result + bias_var\n",
        "\n",
        "    # To deal with a batch of items, we can use the tf.vectorized_map\n",
        "    # function.\n",
        "    # https://www.tensorflow.org/api_docs/python/tf/vectorized_map\n",
        "    result = tf.vectorized_map(\n",
        "        lambda vec: f(vec, self.a_var, self.b_var, self.bias), inputs)\n",
        "    return tf.nn.relu(tf.reshape(result, (-1, 1024)))"
      ],
      "execution_count": 63,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V-CVqIhPnhY_"
      },
      "source": [
        "# Smaller model\n",
        "These two models are effectively the same, but notice how the TN layer has nearly 10x fewer parameters."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XPBvnB95jg4b",
        "outputId": "331a539f-49f2-4a7f-e85d-67a3019d9fba",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        }
      },
      "source": [
        "Dense = tf.keras.layers.Dense\n",
        "fc_model = tf.keras.Sequential(\n",
        "    [\n",
        "     tf.keras.Input(shape=(2,)),\n",
        "     Dense(1024, activation=tf.nn.relu),\n",
        "     Dense(1024, activation=tf.nn.relu),\n",
        "     Dense(1, activation=None)])\n",
        "fc_model.summary()"
      ],
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_10\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense_25 (Dense)            (None, 1024)              3072      \n",
            "                                                                 \n",
            " dense_26 (Dense)            (None, 1024)              1049600   \n",
            "                                                                 \n",
            " dense_27 (Dense)            (None, 1)                 1025      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 1053697 (4.02 MB)\n",
            "Trainable params: 1053697 (4.02 MB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bbKsmK8wIFTp",
        "outputId": "5d26ab68-443a-44e3-8251-e9cc4ab7dfe7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        }
      },
      "source": [
        "tn_model = tf.keras.Sequential(\n",
        "    [\n",
        "     tf.keras.Input(shape=(2,)),\n",
        "     Dense(1024, activation=tf.nn.relu),\n",
        "     # Here, we replace the dense layer with our MPS.\n",
        "     TNLayer(),\n",
        "     TNLayer(),\n",
        "     TNLayer(),\n",
        "     Dense(1, activation=None)])\n",
        "tn_model.summary()"
      ],
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_11\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense_28 (Dense)            (None, 1024)              3072      \n",
            "                                                                 \n",
            " tn_layer_15 (TNLayer)       (None, 1024)              5120      \n",
            "                                                                 \n",
            " tn_layer_16 (TNLayer)       (None, 1024)              5120      \n",
            "                                                                 \n",
            " tn_layer_17 (TNLayer)       (None, 1024)              5120      \n",
            "                                                                 \n",
            " dense_29 (Dense)            (None, 1)                 1025      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 19457 (76.00 KB)\n",
            "Trainable params: 19457 (76.00 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GWwoYp0WnsLA"
      },
      "source": [
        "# Training a model\n",
        "\n",
        "You can train the TN model just as you would a normal neural network model! Here, we give an example of how to do it in Keras."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qDFzOC7sDBJ-"
      },
      "source": [
        "X = np.concatenate([np.random.randn(20, 2) + np.array([3, 3]),\n",
        "                    np.random.randn(20, 2) + np.array([-3, -3]),\n",
        "                    np.random.randn(20, 2) + np.array([-3, 3]),\n",
        "                    np.random.randn(20, 2) + np.array([3, -3])])\n",
        "\n",
        "Y = np.concatenate([np.ones((40)), -np.ones((40))])"
      ],
      "execution_count": 66,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "seconds = time.time()\n",
        "print(\"Time in seconds since beginning of run:\", seconds)\n",
        "local_time = time.ctime(seconds)\n",
        "print(local_time)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "19TWP-1eKURB",
        "outputId": "1adac333-e1dd-40b0-a8ee-82380a03383e"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since beginning of run: 1710205016.8046074\n",
            "Tue Mar 12 00:56:56 2024\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "crc0q1vbIyTj",
        "outputId": "18ef0a02-12f2-4aa2-9464-f7ee7ae13828",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        }
      },
      "source": [
        "tn_model.compile(optimizer=\"adam\", loss=\"mean_squared_error\")\n",
        "tn_model.fit(X, Y, epochs=100, verbose=2)"
      ],
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/100\n",
            "3/3 - 2s - loss: 1.0018 - 2s/epoch - 694ms/step\n",
            "Epoch 2/100\n",
            "3/3 - 0s - loss: 1.0018 - 19ms/epoch - 6ms/step\n",
            "Epoch 3/100\n",
            "3/3 - 0s - loss: 1.0007 - 20ms/epoch - 7ms/step\n",
            "Epoch 4/100\n",
            "3/3 - 0s - loss: 1.0001 - 19ms/epoch - 6ms/step\n",
            "Epoch 5/100\n",
            "3/3 - 0s - loss: 1.0006 - 20ms/epoch - 7ms/step\n",
            "Epoch 6/100\n",
            "3/3 - 0s - loss: 0.9997 - 19ms/epoch - 6ms/step\n",
            "Epoch 7/100\n",
            "3/3 - 0s - loss: 0.9991 - 18ms/epoch - 6ms/step\n",
            "Epoch 8/100\n",
            "3/3 - 0s - loss: 0.9978 - 18ms/epoch - 6ms/step\n",
            "Epoch 9/100\n",
            "3/3 - 0s - loss: 0.9946 - 19ms/epoch - 6ms/step\n",
            "Epoch 10/100\n",
            "3/3 - 0s - loss: 0.9873 - 19ms/epoch - 6ms/step\n",
            "Epoch 11/100\n",
            "3/3 - 0s - loss: 0.9702 - 19ms/epoch - 6ms/step\n",
            "Epoch 12/100\n",
            "3/3 - 0s - loss: 0.9332 - 19ms/epoch - 6ms/step\n",
            "Epoch 13/100\n",
            "3/3 - 0s - loss: 0.8618 - 19ms/epoch - 6ms/step\n",
            "Epoch 14/100\n",
            "3/3 - 0s - loss: 0.7187 - 20ms/epoch - 7ms/step\n",
            "Epoch 15/100\n",
            "3/3 - 0s - loss: 0.4604 - 19ms/epoch - 6ms/step\n",
            "Epoch 16/100\n",
            "3/3 - 0s - loss: 0.1368 - 20ms/epoch - 7ms/step\n",
            "Epoch 17/100\n",
            "3/3 - 0s - loss: 0.1065 - 19ms/epoch - 6ms/step\n",
            "Epoch 18/100\n",
            "3/3 - 0s - loss: 0.0901 - 20ms/epoch - 7ms/step\n",
            "Epoch 19/100\n",
            "3/3 - 0s - loss: 0.0193 - 19ms/epoch - 6ms/step\n",
            "Epoch 20/100\n",
            "3/3 - 0s - loss: 0.0450 - 21ms/epoch - 7ms/step\n",
            "Epoch 21/100\n",
            "3/3 - 0s - loss: 0.0507 - 24ms/epoch - 8ms/step\n",
            "Epoch 22/100\n",
            "3/3 - 0s - loss: 0.0290 - 21ms/epoch - 7ms/step\n",
            "Epoch 23/100\n",
            "3/3 - 0s - loss: 0.0136 - 20ms/epoch - 7ms/step\n",
            "Epoch 24/100\n",
            "3/3 - 0s - loss: 0.0176 - 19ms/epoch - 6ms/step\n",
            "Epoch 25/100\n",
            "3/3 - 0s - loss: 0.0193 - 18ms/epoch - 6ms/step\n",
            "Epoch 26/100\n",
            "3/3 - 0s - loss: 0.0116 - 18ms/epoch - 6ms/step\n",
            "Epoch 27/100\n",
            "3/3 - 0s - loss: 0.0091 - 18ms/epoch - 6ms/step\n",
            "Epoch 28/100\n",
            "3/3 - 0s - loss: 0.0110 - 19ms/epoch - 6ms/step\n",
            "Epoch 29/100\n",
            "3/3 - 0s - loss: 0.0104 - 19ms/epoch - 6ms/step\n",
            "Epoch 30/100\n",
            "3/3 - 0s - loss: 0.0078 - 18ms/epoch - 6ms/step\n",
            "Epoch 31/100\n",
            "3/3 - 0s - loss: 0.0073 - 17ms/epoch - 6ms/step\n",
            "Epoch 32/100\n",
            "3/3 - 0s - loss: 0.0076 - 18ms/epoch - 6ms/step\n",
            "Epoch 33/100\n",
            "3/3 - 0s - loss: 0.0071 - 19ms/epoch - 6ms/step\n",
            "Epoch 34/100\n",
            "3/3 - 0s - loss: 0.0062 - 18ms/epoch - 6ms/step\n",
            "Epoch 35/100\n",
            "3/3 - 0s - loss: 0.0061 - 19ms/epoch - 6ms/step\n",
            "Epoch 36/100\n",
            "3/3 - 0s - loss: 0.0061 - 19ms/epoch - 6ms/step\n",
            "Epoch 37/100\n",
            "3/3 - 0s - loss: 0.0057 - 19ms/epoch - 6ms/step\n",
            "Epoch 38/100\n",
            "3/3 - 0s - loss: 0.0053 - 18ms/epoch - 6ms/step\n",
            "Epoch 39/100\n",
            "3/3 - 0s - loss: 0.0052 - 19ms/epoch - 6ms/step\n",
            "Epoch 40/100\n",
            "3/3 - 0s - loss: 0.0051 - 18ms/epoch - 6ms/step\n",
            "Epoch 41/100\n",
            "3/3 - 0s - loss: 0.0048 - 18ms/epoch - 6ms/step\n",
            "Epoch 42/100\n",
            "3/3 - 0s - loss: 0.0046 - 19ms/epoch - 6ms/step\n",
            "Epoch 43/100\n",
            "3/3 - 0s - loss: 0.0046 - 19ms/epoch - 6ms/step\n",
            "Epoch 44/100\n",
            "3/3 - 0s - loss: 0.0044 - 19ms/epoch - 6ms/step\n",
            "Epoch 45/100\n",
            "3/3 - 0s - loss: 0.0042 - 19ms/epoch - 6ms/step\n",
            "Epoch 46/100\n",
            "3/3 - 0s - loss: 0.0040 - 19ms/epoch - 6ms/step\n",
            "Epoch 47/100\n",
            "3/3 - 0s - loss: 0.0040 - 19ms/epoch - 6ms/step\n",
            "Epoch 48/100\n",
            "3/3 - 0s - loss: 0.0039 - 19ms/epoch - 6ms/step\n",
            "Epoch 49/100\n",
            "3/3 - 0s - loss: 0.0037 - 20ms/epoch - 7ms/step\n",
            "Epoch 50/100\n",
            "3/3 - 0s - loss: 0.0036 - 19ms/epoch - 6ms/step\n",
            "Epoch 51/100\n",
            "3/3 - 0s - loss: 0.0035 - 19ms/epoch - 6ms/step\n",
            "Epoch 52/100\n",
            "3/3 - 0s - loss: 0.0034 - 17ms/epoch - 6ms/step\n",
            "Epoch 53/100\n",
            "3/3 - 0s - loss: 0.0033 - 17ms/epoch - 6ms/step\n",
            "Epoch 54/100\n",
            "3/3 - 0s - loss: 0.0032 - 17ms/epoch - 6ms/step\n",
            "Epoch 55/100\n",
            "3/3 - 0s - loss: 0.0031 - 17ms/epoch - 6ms/step\n",
            "Epoch 56/100\n",
            "3/3 - 0s - loss: 0.0031 - 18ms/epoch - 6ms/step\n",
            "Epoch 57/100\n",
            "3/3 - 0s - loss: 0.0030 - 20ms/epoch - 7ms/step\n",
            "Epoch 58/100\n",
            "3/3 - 0s - loss: 0.0029 - 20ms/epoch - 7ms/step\n",
            "Epoch 59/100\n",
            "3/3 - 0s - loss: 0.0028 - 19ms/epoch - 6ms/step\n",
            "Epoch 60/100\n",
            "3/3 - 0s - loss: 0.0027 - 22ms/epoch - 7ms/step\n",
            "Epoch 61/100\n",
            "3/3 - 0s - loss: 0.0026 - 17ms/epoch - 6ms/step\n",
            "Epoch 62/100\n",
            "3/3 - 0s - loss: 0.0025 - 19ms/epoch - 6ms/step\n",
            "Epoch 63/100\n",
            "3/3 - 0s - loss: 0.0025 - 20ms/epoch - 7ms/step\n",
            "Epoch 64/100\n",
            "3/3 - 0s - loss: 0.0024 - 19ms/epoch - 6ms/step\n",
            "Epoch 65/100\n",
            "3/3 - 0s - loss: 0.0024 - 20ms/epoch - 7ms/step\n",
            "Epoch 66/100\n",
            "3/3 - 0s - loss: 0.0023 - 18ms/epoch - 6ms/step\n",
            "Epoch 67/100\n",
            "3/3 - 0s - loss: 0.0022 - 20ms/epoch - 7ms/step\n",
            "Epoch 68/100\n",
            "3/3 - 0s - loss: 0.0022 - 20ms/epoch - 7ms/step\n",
            "Epoch 69/100\n",
            "3/3 - 0s - loss: 0.0021 - 20ms/epoch - 7ms/step\n",
            "Epoch 70/100\n",
            "3/3 - 0s - loss: 0.0020 - 20ms/epoch - 7ms/step\n",
            "Epoch 71/100\n",
            "3/3 - 0s - loss: 0.0020 - 19ms/epoch - 6ms/step\n",
            "Epoch 72/100\n",
            "3/3 - 0s - loss: 0.0019 - 19ms/epoch - 6ms/step\n",
            "Epoch 73/100\n",
            "3/3 - 0s - loss: 0.0019 - 18ms/epoch - 6ms/step\n",
            "Epoch 74/100\n",
            "3/3 - 0s - loss: 0.0018 - 20ms/epoch - 7ms/step\n",
            "Epoch 75/100\n",
            "3/3 - 0s - loss: 0.0018 - 18ms/epoch - 6ms/step\n",
            "Epoch 76/100\n",
            "3/3 - 0s - loss: 0.0017 - 18ms/epoch - 6ms/step\n",
            "Epoch 77/100\n",
            "3/3 - 0s - loss: 0.0017 - 20ms/epoch - 7ms/step\n",
            "Epoch 78/100\n",
            "3/3 - 0s - loss: 0.0016 - 18ms/epoch - 6ms/step\n",
            "Epoch 79/100\n",
            "3/3 - 0s - loss: 0.0016 - 19ms/epoch - 6ms/step\n",
            "Epoch 80/100\n",
            "3/3 - 0s - loss: 0.0016 - 21ms/epoch - 7ms/step\n",
            "Epoch 81/100\n",
            "3/3 - 0s - loss: 0.0015 - 19ms/epoch - 6ms/step\n",
            "Epoch 82/100\n",
            "3/3 - 0s - loss: 0.0015 - 20ms/epoch - 7ms/step\n",
            "Epoch 83/100\n",
            "3/3 - 0s - loss: 0.0014 - 20ms/epoch - 7ms/step\n",
            "Epoch 84/100\n",
            "3/3 - 0s - loss: 0.0014 - 19ms/epoch - 6ms/step\n",
            "Epoch 85/100\n",
            "3/3 - 0s - loss: 0.0013 - 20ms/epoch - 7ms/step\n",
            "Epoch 86/100\n",
            "3/3 - 0s - loss: 0.0013 - 19ms/epoch - 6ms/step\n",
            "Epoch 87/100\n",
            "3/3 - 0s - loss: 0.0013 - 17ms/epoch - 6ms/step\n",
            "Epoch 88/100\n",
            "3/3 - 0s - loss: 0.0012 - 17ms/epoch - 6ms/step\n",
            "Epoch 89/100\n",
            "3/3 - 0s - loss: 0.0012 - 19ms/epoch - 6ms/step\n",
            "Epoch 90/100\n",
            "3/3 - 0s - loss: 0.0012 - 18ms/epoch - 6ms/step\n",
            "Epoch 91/100\n",
            "3/3 - 0s - loss: 0.0011 - 18ms/epoch - 6ms/step\n",
            "Epoch 92/100\n",
            "3/3 - 0s - loss: 0.0011 - 18ms/epoch - 6ms/step\n",
            "Epoch 93/100\n",
            "3/3 - 0s - loss: 0.0010 - 18ms/epoch - 6ms/step\n",
            "Epoch 94/100\n",
            "3/3 - 0s - loss: 0.0010 - 18ms/epoch - 6ms/step\n",
            "Epoch 95/100\n",
            "3/3 - 0s - loss: 9.9175e-04 - 17ms/epoch - 6ms/step\n",
            "Epoch 96/100\n",
            "3/3 - 0s - loss: 9.7160e-04 - 19ms/epoch - 6ms/step\n",
            "Epoch 97/100\n",
            "3/3 - 0s - loss: 9.1934e-04 - 21ms/epoch - 7ms/step\n",
            "Epoch 98/100\n",
            "3/3 - 0s - loss: 9.1939e-04 - 17ms/epoch - 6ms/step\n",
            "Epoch 99/100\n",
            "3/3 - 0s - loss: 8.9917e-04 - 18ms/epoch - 6ms/step\n",
            "Epoch 100/100\n",
            "3/3 - 0s - loss: 8.5670e-04 - 19ms/epoch - 6ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.src.callbacks.History at 0x7ec19b216a10>"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n-aNP4n3sqG_",
        "outputId": "10a1c3c8-9c1d-403b-8735-4fc1aa9ae039",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 443
        }
      },
      "source": [
        "# Plotting code, feel free to ignore.\n",
        "h = 1.0\n",
        "x_min, x_max = X[:, 0].min() - 5, X[:, 0].max() + 5\n",
        "y_min, y_max = X[:, 1].min() - 5, X[:, 1].max() + 5\n",
        "xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n",
        "                     np.arange(y_min, y_max, h))\n",
        "\n",
        "# here \"model\" is your model's prediction (classification) function\n",
        "Z = tn_model.predict(np.c_[xx.ravel(), yy.ravel()])\n",
        "\n",
        "# Put the result into a color plot\n",
        "Z = Z.reshape(xx.shape)\n",
        "plt.contourf(xx, yy, Z)\n",
        "plt.axis('off')\n",
        "\n",
        "# Plot also the training points\n",
        "plt.scatter(X[:, 0], X[:, 1], c=Y, cmap=plt.cm.Paired)"
      ],
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "14/14 [==============================] - 0s 4ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.collections.PathCollection at 0x7ec19bd2e3e0>"
            ]
          },
          "metadata": {},
          "execution_count": 69
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "seconds = time.time()\n",
        "print(\"Time in seconds since end of run:\", seconds)\n",
        "local_time = time.ctime(seconds)\n",
        "print(local_time)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "wfZCzuq9KY9b",
        "outputId": "a5a7e4a5-1757-43ce-8e12-1540ab2ba9a2"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since end of run: 1710205021.785072\n",
            "Tue Mar 12 00:57:01 2024\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "seconds = time.time()\n",
        "print(\"Time in seconds since beginning of run:\", seconds)\n",
        "local_time = time.ctime(seconds)\n",
        "print(local_time)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Ft6S13x6KuEQ",
        "outputId": "e5a07efd-1112-4e62-9f23-4e0606de0b5a"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since beginning of run: 1710205021.7945516\n",
            "Tue Mar 12 00:57:01 2024\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BMxSJo5gtOmQ"
      },
      "source": [
        "# VS Fully Connected"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NKQx7stYswzU",
        "outputId": "9b88f093-4a6b-4f3d-e006-ab0c3ff052da",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 4115
        }
      },
      "source": [
        "fc_model.compile(optimizer=\"adam\", loss=\"mean_squared_error\")\n",
        "fc_model.fit(X, Y, epochs=100, verbose=2)\n",
        "# Plotting code, feel free to ignore.\n",
        "h = 1.0\n",
        "x_min, x_max = X[:, 0].min() - 5, X[:, 0].max() + 5\n",
        "y_min, y_max = X[:, 1].min() - 5, X[:, 1].max() + 5\n",
        "xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n",
        "                     np.arange(y_min, y_max, h))\n",
        "\n",
        "# here \"model\" is your model's prediction (classification) function\n",
        "Z = fc_model.predict(np.c_[xx.ravel(), yy.ravel()])\n",
        "\n",
        "# Put the result into a color plot\n",
        "Z = Z.reshape(xx.shape)\n",
        "plt.contourf(xx, yy, Z)\n",
        "plt.axis('off')\n",
        "\n",
        "# Plot also the training points\n",
        "plt.scatter(X[:, 0], X[:, 1], c=Y, cmap=plt.cm.Paired)"
      ],
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/100\n",
            "3/3 - 1s - loss: 0.5656 - 651ms/epoch - 217ms/step\n",
            "Epoch 2/100\n",
            "3/3 - 0s - loss: 0.1959 - 29ms/epoch - 10ms/step\n",
            "Epoch 3/100\n",
            "3/3 - 0s - loss: 0.1423 - 27ms/epoch - 9ms/step\n",
            "Epoch 4/100\n",
            "3/3 - 0s - loss: 0.0917 - 23ms/epoch - 8ms/step\n",
            "Epoch 5/100\n",
            "3/3 - 0s - loss: 0.0828 - 24ms/epoch - 8ms/step\n",
            "Epoch 6/100\n",
            "3/3 - 0s - loss: 0.0827 - 26ms/epoch - 9ms/step\n",
            "Epoch 7/100\n",
            "3/3 - 0s - loss: 0.0680 - 25ms/epoch - 8ms/step\n",
            "Epoch 8/100\n",
            "3/3 - 0s - loss: 0.0680 - 29ms/epoch - 10ms/step\n",
            "Epoch 9/100\n",
            "3/3 - 0s - loss: 0.0605 - 23ms/epoch - 8ms/step\n",
            "Epoch 10/100\n",
            "3/3 - 0s - loss: 0.0632 - 26ms/epoch - 9ms/step\n",
            "Epoch 11/100\n",
            "3/3 - 0s - loss: 0.0537 - 22ms/epoch - 7ms/step\n",
            "Epoch 12/100\n",
            "3/3 - 0s - loss: 0.0523 - 25ms/epoch - 8ms/step\n",
            "Epoch 13/100\n",
            "3/3 - 0s - loss: 0.0522 - 23ms/epoch - 8ms/step\n",
            "Epoch 14/100\n",
            "3/3 - 0s - loss: 0.0483 - 25ms/epoch - 8ms/step\n",
            "Epoch 15/100\n",
            "3/3 - 0s - loss: 0.0498 - 27ms/epoch - 9ms/step\n",
            "Epoch 16/100\n",
            "3/3 - 0s - loss: 0.0444 - 26ms/epoch - 9ms/step\n",
            "Epoch 17/100\n",
            "3/3 - 0s - loss: 0.0487 - 23ms/epoch - 8ms/step\n",
            "Epoch 18/100\n",
            "3/3 - 0s - loss: 0.0467 - 24ms/epoch - 8ms/step\n",
            "Epoch 19/100\n",
            "3/3 - 0s - loss: 0.0419 - 25ms/epoch - 8ms/step\n",
            "Epoch 20/100\n",
            "3/3 - 0s - loss: 0.0439 - 28ms/epoch - 9ms/step\n",
            "Epoch 21/100\n",
            "3/3 - 0s - loss: 0.0406 - 25ms/epoch - 8ms/step\n",
            "Epoch 22/100\n",
            "3/3 - 0s - loss: 0.0414 - 23ms/epoch - 8ms/step\n",
            "Epoch 23/100\n",
            "3/3 - 0s - loss: 0.0421 - 25ms/epoch - 8ms/step\n",
            "Epoch 24/100\n",
            "3/3 - 0s - loss: 0.0378 - 21ms/epoch - 7ms/step\n",
            "Epoch 25/100\n",
            "3/3 - 0s - loss: 0.0382 - 26ms/epoch - 9ms/step\n",
            "Epoch 26/100\n",
            "3/3 - 0s - loss: 0.0425 - 24ms/epoch - 8ms/step\n",
            "Epoch 27/100\n",
            "3/3 - 0s - loss: 0.0505 - 28ms/epoch - 9ms/step\n",
            "Epoch 28/100\n",
            "3/3 - 0s - loss: 0.0423 - 24ms/epoch - 8ms/step\n",
            "Epoch 29/100\n",
            "3/3 - 0s - loss: 0.0513 - 22ms/epoch - 7ms/step\n",
            "Epoch 30/100\n",
            "3/3 - 0s - loss: 0.0385 - 25ms/epoch - 8ms/step\n",
            "Epoch 31/100\n",
            "3/3 - 0s - loss: 0.0392 - 27ms/epoch - 9ms/step\n",
            "Epoch 32/100\n",
            "3/3 - 0s - loss: 0.0417 - 24ms/epoch - 8ms/step\n",
            "Epoch 33/100\n",
            "3/3 - 0s - loss: 0.0414 - 26ms/epoch - 9ms/step\n",
            "Epoch 34/100\n",
            "3/3 - 0s - loss: 0.0374 - 28ms/epoch - 9ms/step\n",
            "Epoch 35/100\n",
            "3/3 - 0s - loss: 0.0348 - 24ms/epoch - 8ms/step\n",
            "Epoch 36/100\n",
            "3/3 - 0s - loss: 0.0319 - 29ms/epoch - 10ms/step\n",
            "Epoch 37/100\n",
            "3/3 - 0s - loss: 0.0429 - 25ms/epoch - 8ms/step\n",
            "Epoch 38/100\n",
            "3/3 - 0s - loss: 0.0382 - 24ms/epoch - 8ms/step\n",
            "Epoch 39/100\n",
            "3/3 - 0s - loss: 0.0266 - 23ms/epoch - 8ms/step\n",
            "Epoch 40/100\n",
            "3/3 - 0s - loss: 0.0399 - 25ms/epoch - 8ms/step\n",
            "Epoch 41/100\n",
            "3/3 - 0s - loss: 0.0336 - 26ms/epoch - 9ms/step\n",
            "Epoch 42/100\n",
            "3/3 - 0s - loss: 0.0293 - 27ms/epoch - 9ms/step\n",
            "Epoch 43/100\n",
            "3/3 - 0s - loss: 0.0304 - 21ms/epoch - 7ms/step\n",
            "Epoch 44/100\n",
            "3/3 - 0s - loss: 0.0370 - 24ms/epoch - 8ms/step\n",
            "Epoch 45/100\n",
            "3/3 - 0s - loss: 0.0295 - 28ms/epoch - 9ms/step\n",
            "Epoch 46/100\n",
            "3/3 - 0s - loss: 0.0278 - 26ms/epoch - 9ms/step\n",
            "Epoch 47/100\n",
            "3/3 - 0s - loss: 0.0298 - 24ms/epoch - 8ms/step\n",
            "Epoch 48/100\n",
            "3/3 - 0s - loss: 0.0244 - 26ms/epoch - 9ms/step\n",
            "Epoch 49/100\n",
            "3/3 - 0s - loss: 0.0270 - 22ms/epoch - 7ms/step\n",
            "Epoch 50/100\n",
            "3/3 - 0s - loss: 0.0191 - 25ms/epoch - 8ms/step\n",
            "Epoch 51/100\n",
            "3/3 - 0s - loss: 0.0257 - 24ms/epoch - 8ms/step\n",
            "Epoch 52/100\n",
            "3/3 - 0s - loss: 0.0229 - 22ms/epoch - 7ms/step\n",
            "Epoch 53/100\n",
            "3/3 - 0s - loss: 0.0226 - 24ms/epoch - 8ms/step\n",
            "Epoch 54/100\n",
            "3/3 - 0s - loss: 0.0251 - 24ms/epoch - 8ms/step\n",
            "Epoch 55/100\n",
            "3/3 - 0s - loss: 0.0231 - 25ms/epoch - 8ms/step\n",
            "Epoch 56/100\n",
            "3/3 - 0s - loss: 0.0268 - 25ms/epoch - 8ms/step\n",
            "Epoch 57/100\n",
            "3/3 - 0s - loss: 0.0274 - 23ms/epoch - 8ms/step\n",
            "Epoch 58/100\n",
            "3/3 - 0s - loss: 0.0182 - 24ms/epoch - 8ms/step\n",
            "Epoch 59/100\n",
            "3/3 - 0s - loss: 0.0233 - 24ms/epoch - 8ms/step\n",
            "Epoch 60/100\n",
            "3/3 - 0s - loss: 0.0189 - 25ms/epoch - 8ms/step\n",
            "Epoch 61/100\n",
            "3/3 - 0s - loss: 0.0133 - 26ms/epoch - 9ms/step\n",
            "Epoch 62/100\n",
            "3/3 - 0s - loss: 0.0144 - 23ms/epoch - 8ms/step\n",
            "Epoch 63/100\n",
            "3/3 - 0s - loss: 0.0157 - 24ms/epoch - 8ms/step\n",
            "Epoch 64/100\n",
            "3/3 - 0s - loss: 0.0119 - 26ms/epoch - 9ms/step\n",
            "Epoch 65/100\n",
            "3/3 - 0s - loss: 0.0188 - 29ms/epoch - 10ms/step\n",
            "Epoch 66/100\n",
            "3/3 - 0s - loss: 0.0130 - 28ms/epoch - 9ms/step\n",
            "Epoch 67/100\n",
            "3/3 - 0s - loss: 0.0116 - 27ms/epoch - 9ms/step\n",
            "Epoch 68/100\n",
            "3/3 - 0s - loss: 0.0110 - 27ms/epoch - 9ms/step\n",
            "Epoch 69/100\n",
            "3/3 - 0s - loss: 0.0073 - 26ms/epoch - 9ms/step\n",
            "Epoch 70/100\n",
            "3/3 - 0s - loss: 0.0097 - 27ms/epoch - 9ms/step\n",
            "Epoch 71/100\n",
            "3/3 - 0s - loss: 0.0088 - 23ms/epoch - 8ms/step\n",
            "Epoch 72/100\n",
            "3/3 - 0s - loss: 0.0063 - 25ms/epoch - 8ms/step\n",
            "Epoch 73/100\n",
            "3/3 - 0s - loss: 0.0058 - 27ms/epoch - 9ms/step\n",
            "Epoch 74/100\n",
            "3/3 - 0s - loss: 0.0060 - 23ms/epoch - 8ms/step\n",
            "Epoch 75/100\n",
            "3/3 - 0s - loss: 0.0094 - 25ms/epoch - 8ms/step\n",
            "Epoch 76/100\n",
            "3/3 - 0s - loss: 0.0106 - 29ms/epoch - 10ms/step\n",
            "Epoch 77/100\n",
            "3/3 - 0s - loss: 0.0083 - 22ms/epoch - 7ms/step\n",
            "Epoch 78/100\n",
            "3/3 - 0s - loss: 0.0048 - 25ms/epoch - 8ms/step\n",
            "Epoch 79/100\n",
            "3/3 - 0s - loss: 0.0048 - 24ms/epoch - 8ms/step\n",
            "Epoch 80/100\n",
            "3/3 - 0s - loss: 0.0046 - 26ms/epoch - 9ms/step\n",
            "Epoch 81/100\n",
            "3/3 - 0s - loss: 0.0029 - 26ms/epoch - 9ms/step\n",
            "Epoch 82/100\n",
            "3/3 - 0s - loss: 0.0026 - 24ms/epoch - 8ms/step\n",
            "Epoch 83/100\n",
            "3/3 - 0s - loss: 0.0030 - 27ms/epoch - 9ms/step\n",
            "Epoch 84/100\n",
            "3/3 - 0s - loss: 0.0032 - 23ms/epoch - 8ms/step\n",
            "Epoch 85/100\n",
            "3/3 - 0s - loss: 0.0040 - 25ms/epoch - 8ms/step\n",
            "Epoch 86/100\n",
            "3/3 - 0s - loss: 0.0045 - 31ms/epoch - 10ms/step\n",
            "Epoch 87/100\n",
            "3/3 - 0s - loss: 0.0047 - 23ms/epoch - 8ms/step\n",
            "Epoch 88/100\n",
            "3/3 - 0s - loss: 0.0033 - 27ms/epoch - 9ms/step\n",
            "Epoch 89/100\n",
            "3/3 - 0s - loss: 0.0034 - 27ms/epoch - 9ms/step\n",
            "Epoch 90/100\n",
            "3/3 - 0s - loss: 0.0083 - 26ms/epoch - 9ms/step\n",
            "Epoch 91/100\n",
            "3/3 - 0s - loss: 0.0109 - 27ms/epoch - 9ms/step\n",
            "Epoch 92/100\n",
            "3/3 - 0s - loss: 0.0065 - 27ms/epoch - 9ms/step\n",
            "Epoch 93/100\n",
            "3/3 - 0s - loss: 0.0046 - 23ms/epoch - 8ms/step\n",
            "Epoch 94/100\n",
            "3/3 - 0s - loss: 0.0068 - 28ms/epoch - 9ms/step\n",
            "Epoch 95/100\n",
            "3/3 - 0s - loss: 0.0096 - 23ms/epoch - 8ms/step\n",
            "Epoch 96/100\n",
            "3/3 - 0s - loss: 0.0103 - 23ms/epoch - 8ms/step\n",
            "Epoch 97/100\n",
            "3/3 - 0s - loss: 0.0119 - 23ms/epoch - 8ms/step\n",
            "Epoch 98/100\n",
            "3/3 - 0s - loss: 0.0069 - 24ms/epoch - 8ms/step\n",
            "Epoch 99/100\n",
            "3/3 - 0s - loss: 0.0075 - 26ms/epoch - 9ms/step\n",
            "Epoch 100/100\n",
            "3/3 - 0s - loss: 0.0057 - 22ms/epoch - 7ms/step\n",
            "14/14 [==============================] - 0s 2ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.collections.PathCollection at 0x7ec19ab47940>"
            ]
          },
          "metadata": {},
          "execution_count": 72
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "seconds = time.time()\n",
        "print(\"Time in seconds since end of run:\", seconds)\n",
        "local_time = time.ctime(seconds)\n",
        "print(local_time)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "YyOarWssKyjN",
        "outputId": "9c938561-deb9-49c0-e778-804d4d1a3c92"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since end of run: 1710205025.5163167\n",
            "Tue Mar 12 00:57:05 2024\n"
          ]
        }
      ]
    }
  ]
}